Multiprocessor systems are typically used in applications wherein several execution processors, each having a dedicated function, can relieve a central processor of processing load. In addition, parallel processing by such execution processors may allow for reduced overall processing time.
The various execution processors execute a series of tasks. A task is a series of defined steps to be executed by a processor, typically executed as the result of a series of processor executable instructions stored within processor readable memory. Typically, the series of instructions that define the task are stored in processor readable memory associated with the given execution processor. As well, a task typically has a defined beginning and end. A series of tasks, in turn, may be used to execute a program.
Many execution processors initiate performance of a particular task in response to sensing that an associated register of another execution processor has been modified. A given task may be arranged to act on data that is in a memory shared by multiple execution processors or to act on data in registers that are local to the execution processor executing the given task.
Tasks running on a multiprocessor system, which may have many tasks running concurrently on many execution processors, typically have both data and control dependencies among each other.
Data dependency between two tasks requires access to data being processed by a first task for processing by a second task. As such, tasks must be managed so that the second task does not attempt to access the data until the processing by the first task is complete.
Control dependency between two tasks requires access to a system component, that is receiving instructions according to processing by a first task running at a first execution processor, by a second execution processor according to processing by a second task. In such a case, the tasks must be managed so that the second task does not attempt to generate instructions for the system component until the processing by the first task is complete.
In known multiprocessor systems, fixed, hardware flow-control may be arranged among execution processors to manage data and task dependencies. The tasks to be run at each of the execution processors must be known ahead of time, along with the data and control dependencies of the known tasks. The execution processors are prearranged to indicate the completion of a given task to other execution processors for which such an indication is useful in determining timing of the initiation of tasks at the other execution processors. This solution is not flexible or programmable.
In other multiprocessor systems, a central processor initiates tasks at execution processors and periodically polls the execution processors to determine the tasks running at the execution processors. The central processor may wait until a result of polling a first execution processor is an indication that a first task has completed before instructing a second execution processor to initiate a second task, where the second task has data or control dependencies on the first task. In order that the second task may be initiated without undue delay after the completion of the first task, the central processor must poll the execution processors frequently. Although this solution may be considered flexible and/or programmable, it requires valuable central processor cycles resulting from the central processor's frequent interaction with the execution processors of the multiprocessor system.
In yet other multiprocessor systems, the central processor responds to interrupts generated by the execution processors at the completion of tasks. Thus excessive central processor cycles are eliminated. Central processor interrupts initiated by the execution processors indicate task completion. The central processor may then use this information, along with information about data and control dependencies between tasks to initiate dependent tasks. However, typical central processor response time to interrupts may impair multiprocessor system performance: the central processor may not be able to keep up with tasks that need to communicate with each other on a frequent basis.
Clearly, then, there is a need for a new solution for managing tasks in a multiprocessor system, where the new solution allows for flexible control of the initiation of the execution of tasks at the execution processors.